home *** CD-ROM | disk | FTP | other *** search
/ HAM Radio 3.2 / Ham Radio Version 3.2 (Chestnut CD-ROMs)(1993).ISO / packet / n17jsrc / axheard.c < prev    next >
C/C++ Source or Header  |  1991-07-10  |  5KB  |  254 lines
  1. /* AX25 link callsign monitoring. Also contains beginnings of
  2.  * an automatic link quality monitoring scheme (incomplete)
  3.  *
  4.  * Copyright 1991 Phil Karn, KA9Q
  5.  */
  6. #include <ctype.h>
  7. #include "global.h"
  8. #include "mbuf.h"
  9. #include "iface.h"
  10. #include "ax25.h"
  11. #include "ip.h"
  12. #include "timer.h"
  13.  
  14. #define iscallsign(c) ((isupper(c)) || (isdigit(c)) || (c =='\x20'))
  15. int axheard_filter_flag = AXHEARD_PASS;
  16.  
  17. static struct lq *al_create __ARGS((struct iface *ifp,char *addr));
  18. static struct ld *ad_lookup __ARGS((struct iface *ifp,char *addr,int sort));
  19. static struct ld *ad_create __ARGS((struct iface *ifp,char *addr));
  20. struct lq *Lq;
  21. struct ld *Ld;
  22.  
  23. #ifdef    notdef
  24. /* Send link quality reports to interface */
  25. void
  26. genrpt(ifp)
  27. struct iface *ifp;
  28. {
  29.     struct mbuf *bp;
  30.     register char *cp;
  31.     int i;
  32.     struct lq *lp;
  33.     int maxentries,nentries;
  34.  
  35.     maxentries = (Paclen - LQHDR) / LQENTRY;
  36.     if((bp = alloc_mbuf(Paclen)) == NULLBUF)
  37.         return;
  38.     cp = bp->data;
  39.     nentries = 0;
  40.  
  41.     /* Build and emit header */
  42.     cp = putlqhdr(cp,LINKVERS,Ip_addr);
  43.  
  44.     /* First entry is for ourselves. Since we're examining the Axsent
  45.      * variable before we've sent this frame, add one to it so it'll
  46.      * match the receiver's count after he gets this frame.
  47.      */
  48.     cp = putlqentry(cp,ifp->hwaddr,Axsent+1);
  49.     nentries++;
  50.  
  51.     /* Now add entries from table */
  52.     for(lp = lq;lp != NULLLQ;lp = lp->next){
  53.         cp = putlqentry(cp,&lp->addr,lp->currxcnt);
  54.         if(++nentries >= MAXENTRIES){
  55.             /* Flush */
  56.             bp->cnt = nentries*LQENTRY + LQHDR;
  57.             ax_output(ifp,Ax25multi[0],ifp->hwaddr,PID_LQ,bp);
  58.             if((bp = alloc_mbuf(Paclen)) == NULLBUF)
  59.                 return;
  60.             cp = bp->data;
  61.         }
  62.     }
  63.     if(nentries > 0){
  64.         bp->cnt = nentries*LQENTRY + LQHDR;
  65.         ax_output(ifp,Ax25multi[0],ifp->hwaddr,LQPID,bp);
  66.     } else {
  67.         free_p(bp);
  68.     }
  69. }
  70.  
  71. /* Pull the header off a link quality packet */
  72. void
  73. getlqhdr(hp,bpp)
  74. struct lqhdr *hp;
  75. struct mbuf **bpp;
  76. {
  77.     hp->version = pull16(bpp);
  78.     hp->ip_addr = pull32(bpp);
  79. }
  80.  
  81. /* Put a header on a link quality packet.
  82.  * Return pointer to buffer immediately following header
  83.  */
  84. char *
  85. putlqhdr(cp,version,ip_addr)
  86. register char *cp;
  87. int16 version;
  88. int32 ip_addr;
  89. {
  90.     cp = put16(cp,version);
  91.     return put32(cp,ip_addr);
  92. }
  93.  
  94. /* Pull an entry off a link quality packet */
  95. void
  96. getlqentry(ep,bpp)
  97. struct lqentry *ep;
  98. struct mbuf **bpp;
  99. {
  100.     pullup(bpp,ep->addr,AXALEN);
  101.     ep->count = pull32(bpp);
  102. }
  103.  
  104. /* Put an entry on a link quality packet
  105.  * Return pointer to buffer immediately following header
  106.  */
  107. char *
  108. putlqentry(cp,addr,count)
  109. char *cp;
  110. char *addr;
  111. int32 count;
  112. {
  113.     memcpy(cp,addr,AXALEN);
  114.     cp += AXALEN;
  115.     return put32(cp,count);
  116. }
  117. #endif
  118.  
  119. /* Log the source address of an incoming packet */
  120. void
  121. logsrc(ifp,addr)
  122. struct iface *ifp;
  123. char *addr;
  124. {
  125.     register struct lq *lp;
  126.  
  127.     if(axheard_filter_flag & AXHEARD_NOSRC)
  128.         return;
  129.     {
  130.         register unsigned char c;
  131.         register int i = 0;
  132.         while(i < AXALEN-1){
  133.             c = *(addr+i);
  134.             c >>= 1;
  135.             if(!iscallsign(c))
  136.                 return;
  137.             i++;
  138.         }
  139.     }
  140.     
  141.     if((lp = al_lookup(ifp,addr,1)) == NULLLQ)
  142.          if((lp = al_create(ifp,addr)) == NULLLQ)
  143.             return;
  144.     lp->currxcnt++;
  145.     lp->time = secclock();
  146. }
  147. /* Log the destination address of an incoming packet */
  148. void
  149. logdest(ifp,addr)
  150. struct iface *ifp;
  151. char *addr;
  152. {
  153.     register struct ld *lp;
  154.  
  155.     if(axheard_filter_flag & AXHEARD_NODST)
  156.         return;
  157.     {
  158.         register unsigned char c;
  159.         register int i = 0;
  160.         while(i < AXALEN-1){
  161.             c = *(addr+i);
  162.             c >>= 1;
  163.             if(!iscallsign(c))
  164.                 return;
  165.             i++;
  166.         }
  167.     }
  168.     
  169.     if((lp = ad_lookup(ifp,addr,1)) == NULLLD)
  170.         if((lp = ad_create(ifp,addr)) == NULLLD)
  171.             return;
  172.     lp->currxcnt++;
  173.     lp->time = secclock();
  174. }
  175. /* Look up an entry in the source data base */
  176. struct lq *
  177. al_lookup(ifp,addr,sort)
  178. struct iface *ifp;
  179. char *addr;
  180. int sort;
  181. {
  182.     register struct lq *lp;
  183.     struct lq *lplast = NULLLQ;
  184.  
  185.     for(lp = Lq;lp != NULLLQ;lplast = lp,lp = lp->next){
  186.         if(addreq(lp->addr,addr) && (lp->iface == ifp)){
  187.             if(sort && lplast != NULLLQ){
  188.                 /* Move entry to top of list */
  189.                 lplast->next = lp->next;
  190.                 lp->next = Lq;
  191.                 Lq = lp;
  192.             }
  193.             return lp;
  194.         }
  195.     }
  196.     return NULLLQ;
  197. }
  198. /* Create a new entry in the source database */
  199. static struct lq *
  200. al_create(ifp,addr)
  201. struct iface *ifp;
  202. char *addr;
  203. {
  204.     register struct lq *lp;
  205.  
  206.     lp = (struct lq *)callocw(1,sizeof(struct lq));
  207.     memcpy(lp->addr,addr,AXALEN);
  208.     lp->next = Lq;
  209.     Lq = lp;
  210.     lp->iface = ifp;
  211.  
  212.     return lp;
  213. }
  214. /* Look up an entry in the destination database */
  215. static struct ld *
  216. ad_lookup(ifp,addr,sort)
  217. struct iface *ifp;
  218. char *addr;
  219. int sort;
  220. {
  221.     register struct ld *lp;
  222.     struct ld *lplast = NULLLD;
  223.  
  224.     for(lp = Ld;lp != NULLLD;lplast = lp,lp = lp->next){
  225.         if((lp->iface == ifp) && addreq(lp->addr,addr)){
  226.             if(sort && lplast != NULLLD){
  227.                 /* Move entry to top of list */
  228.                 lplast->next = lp->next;
  229.                 lp->next = Ld;
  230.                 Ld = lp;
  231.             }
  232.             return lp;
  233.         }
  234.     }
  235.     return NULLLD;
  236. }
  237. /* Create a new entry in the destination database */
  238. static struct ld *
  239. ad_create(ifp,addr)
  240. struct iface *ifp;
  241. char *addr;
  242. {
  243.     register struct ld *lp;
  244.  
  245.     lp = (struct ld *)callocw(1,sizeof(struct ld));
  246.     memcpy(lp->addr,addr,AXALEN);
  247.     lp->next = Ld;
  248.     Ld = lp;
  249.     lp->iface = ifp;
  250.  
  251.     return lp;
  252. }
  253.  
  254.